audio_separator/separator/uvr_lib_v5/demucs/hdemucs_rocm.py (4)

197-197: Unused loop variable.

The loop variable k is not used within the loop body. Rename to _ to indicate it's intentionally unused.

Proposed fix

-        for k in range(len(split_ratios) + 1):
+        for _ in range(len(split_ratios) + 1):

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@audio_separator/separator/uvr_lib_v5/demucs/hdemucs_rocm.py` at line 197, The
for-loop in hdemucs_rocm.py uses an unused loop variable `k` ("for k in
range(len(split_ratios) + 1):"); rename `k` to `_` to indicate the variable is
intentionally unused (i.e., change to "for _ in range(len(split_ratios) + 1):")
so linters won't flag an unused variable while keeping the loop behavior the
same; locate the loop referencing `split_ratios` in the file and update the
iterator variable accordingly.

---

634-634: Redundant int() call.

In Python 3, math.ceil() returns an int, so the outer int() call is unnecessary.

Proposed fix

-            le = int(math.ceil(x.shape[-1] / hl))
+            le = math.ceil(x.shape[-1] / hl)

The same applies to lines 654 and 656.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@audio_separator/separator/uvr_lib_v5/demucs/hdemucs_rocm.py` at line 634,
Remove the redundant outer int() wrappers around math.ceil(...) where lengths
are computed (e.g., the assignment to le using math.ceil(x.shape[-1] / hl) and
the similar calculations at the other two occurrences); math.ceil already
returns an int in Python 3, so replace expressions like le = int(math.ceil(...))
with le = math.ceil(...), and do the same for the other two variables (the other
math.ceil uses in the same scope).

---

51-51: Typo in comment.

"nornalize" should be "normalize".

Proposed fix

-            # when summing gaussian, overscale raises as sqrt(n), so we nornalize by that.
+            # when summing gaussian, overscale raises as sqrt(n), so we normalize by that.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@audio_separator/separator/uvr_lib_v5/demucs/hdemucs_rocm.py` at line 51, Fix
the typo in the inline comment that currently reads "when summing gaussian,
overscale raises as sqrt(n), so we nornalize by that." — change "nornalize" to
"normalize" in the comment within hdemucs_rocm.py (the comment near the Gaussian
summing/overscale logic) so it reads "... so we normalize by that.".

---

214-214: Consider adding strict=True to zip() for safety.

In Python 3.10+, zip(..., strict=True) raises ValueError if iterables have different lengths. Since ratios and self.layers should always match in length, adding strict=True would catch configuration errors early.

Proposed fix

-        for ratio, layer in zip(ratios, self.layers):
+        for ratio, layer in zip(ratios, self.layers, strict=True):

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@audio_separator/separator/uvr_lib_v5/demucs/hdemucs_rocm.py` at line 214, The
loop using zip(ratios, self.layers) can silently miss length mismatches; change
it to zip(ratios, self.layers, strict=True) so a ValueError is raised if their
lengths differ, updating the for-loop in the same location (the line with for
ratio, layer in zip(ratios, self.layers)) to include strict=True to catch
configuration errors early.

audio_separator/separator/uvr_lib_v5/tfc_tdf_v3.py (2)

6-8: Duplicate is_rocm() function - consider centralizing.

This is_rocm() function is identical to the one in stft.py (lines 4-6). Having duplicate implementations creates risk of divergence if the detection logic needs updating. Consider moving to a shared utility module.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@audio_separator/separator/uvr_lib_v5/tfc_tdf_v3.py` around lines 6 - 8, The
is_rocm() function in tfc_tdf_v3.py duplicates the implementation found in
stft.py; refactor by moving the detection logic into a single shared utility
(e.g., a new or existing utils module) and replace both local definitions with
imports of that shared is_rocm function; update references in tfc_tdf_v3.py and
stft.py to import the centralized is_rocm and remove the duplicate function to
avoid future divergence.

---

51-61: Avoid catching bare Exception.

The except Exception is too broad and may hide unexpected errors. Consider catching specific exceptions or at minimum logging the error.

Proposed improvement

         try:
             x = torch.stft(
                 x,
                 n_fft=self.n_fft,
                 hop_length=self.hop_length,
                 window=window,
                 center=True,
                 return_complex=False,
             )
-        except Exception as e:
+        except RuntimeError:
             # Fallback: try with return_complex=True
             x_complex = torch.stft(

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@audio_separator/separator/uvr_lib_v5/tfc_tdf_v3.py` around lines 51 - 61,
Replace the broad "except Exception as e:" around the torch.stft fallback with a
narrow, specific exception handler (e.g., "except RuntimeError as e:") and
ensure the caught error is logged before proceeding to the fallback; reference
the torch.stft call and the x_complex -> x stacking logic and either log the
exception via the module logger (including the error message/traceback) or
re-raise unexpected exception types instead of silencing them so failures in
torch.stft(return_complex=...) are visible.

Dockerfile.rocm (2)

8-12: Add --no-install-recommends to reduce image size.

As flagged by static analysis, adding --no-install-recommends prevents unnecessary packages from being installed.

Proposed fix

 # Install necessary packages
-RUN apt-get update && apt-get install -y \
+RUN apt-get update && apt-get install -y --no-install-recommends \
     ffmpeg \
     python3 \
     python3-pip \
     && rm -rf /var/lib/apt/lists/*

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@Dockerfile.rocm` around lines 8 - 12, The apt install line in the Dockerfile
RUN step installs recommended packages increasing image size; update the RUN
command that includes apt-get install -y ffmpeg python3 python3-pip (the install
invocation) to add the --no-install-recommends flag to apt-get install and keep
the existing cleanup (rm -rf /var/lib/apt/lists/*) so only essential packages
are installed and image size is reduced.

---

24-26: Hardcoded GPU architecture limits portability.

The environment variables HSA_OVERRIDE_GFX_VERSION=10.3.2 and PYTORCH_ROCM_ARCH=gfx1030 are specific to RX 6600 series GPUs. Users with different AMD GPUs (e.g., RX 7000 series, MI-series) will need to override these.

Consider documenting this in comments or using build arguments:

Proposed improvement

-# Set environment variables for AMD RX 6600 series
-ENV HSA_OVERRIDE_GFX_VERSION=10.3.2
-ENV PYTORCH_ROCM_ARCH=gfx1030
+# Default environment variables for AMD RX 6600 series (gfx1032)
+# Override these for other GPUs:
+#   RX 7900: HSA_OVERRIDE_GFX_VERSION=11.0.0, PYTORCH_ROCM_ARCH=gfx1100
+#   MI250X:  HSA_OVERRIDE_GFX_VERSION=9.4.2, PYTORCH_ROCM_ARCH=gfx90a
+ARG HSA_OVERRIDE_GFX_VERSION=10.3.2
+ARG PYTORCH_ROCM_ARCH=gfx1030
+ENV HSA_OVERRIDE_GFX_VERSION=${HSA_OVERRIDE_GFX_VERSION}
+ENV PYTORCH_ROCM_ARCH=${PYTORCH_ROCM_ARCH}

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@Dockerfile.rocm` around lines 24 - 26, The Dockerfile hardcodes AMD GPU
targets via ENV HSA_OVERRIDE_GFX_VERSION=10.3.2 and ENV
PYTORCH_ROCM_ARCH=gfx1030 which reduces portability; change these to
configurable build arguments (e.g., ARG HSA_OVERRIDE_GFX_VERSION and ARG
PYTORCH_ROCM_ARCH) and set the ENV values from those args, and add a comment
above explaining they should be overridden for different GPUs (RX7000, MI
series, etc.) so users can pass --build-arg to customize the GPU target at build
time.

audio_separator/separator/uvr_lib_v5/stft.py (2)

64-74: Avoid catching bare Exception.

Similar to tfc_tdf_v3.py, catching bare Exception is too broad. RuntimeError is more appropriate for PyTorch operation failures.

Proposed fix

-        except Exception as e:
+        except RuntimeError:
             # Fallback: try with return_complex=True

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@audio_separator/separator/uvr_lib_v5/stft.py` around lines 64 - 74, The
except block currently catches a bare Exception around the torch.stft call;
change it to catch RuntimeError instead to avoid swallowing unrelated errors.
Specifically, in the code that computes stft_complex from reshaped_tensor (using
torch.stft with self.n_fft, self.hop_length and stft_window) replace "except
Exception as e" with "except RuntimeError as e" and keep the fallback logic that
constructs stft_output from stft_complex.real and .imag so only PyTorch
operation failures are caught.

---

4-6: Duplicate is_rocm() implementation.

As noted for tfc_tdf_v3.py, this function is duplicated. Consider extracting to a shared module like audio_separator/separator/uvr_lib_v5/utils.py.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@audio_separator/separator/uvr_lib_v5/stft.py` around lines 4 - 6, Duplicate
is_rocm() exists in stft.py and tfc_tdf_v3.py; extract a single implementation
into a new utility module (e.g., create
audio_separator/separator/uvr_lib_v5/utils.py with def is_rocm(): return "+rocm"
in torch.__version__), remove the duplicate definitions from stft.py and
tfc_tdf_v3.py, and update those modules to import is_rocm from the new utils
module (use from .utils import is_rocm) so both files reference the same shared
function.

debug_results.txt (1)

1-166: Consider excluding diagnostic output from version control.

This file appears to be output from a debug script run on a specific system. Committing environment-specific diagnostic logs may not be appropriate for the repository. Consider:

1. Adding debug_results.txt to .gitignore
2. Or renaming to debug_results_example.txt to indicate it's a reference

Also note: Line 162 shows MDX model operations failed with an empty exception message, which may warrant investigation.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@debug_results.txt` around lines 1 - 166, This file debug_results.txt is a
machine-specific diagnostic log and should not be committed; either add
debug_results.txt to .gitignore or rename it to debug_results_example.txt (to
keep a sanitized example), and remove the committed debug_results.txt from the
repo history/next commit. Also, investigate the MDX model failure reported as
"MDX model operations: FAILED" (search for your MDX loader/initialization and
inference entrypoints) to capture and log the actual exception so future
diagnostic runs show a concrete error instead of an empty exception message.

README.md (1)

122-124: Clarify that CUDAExecutionProvider is expected for ROCm.

The success message states ONNXruntime has CUDAExecutionProvider available for ROCm setups, which may confuse users expecting a ROCm-specific provider. Consider clarifying this is expected behavior:

Proposed improvement

 💬 If successfully configured, you should see this log message when running `audio-separator --env_info`:
- `ONNXruntime has CUDAExecutionProvider available, enabling acceleration`
+ `ONNXruntime has CUDAExecutionProvider available, enabling acceleration`
+
+**Note:** On ROCm systems, the CUDAExecutionProvider is used for AMD GPU acceleration through ROCm's HIP compatibility layer. This is expected behavior.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@README.md` around lines 122 - 124, Update the README text that shows the
success log so users on ROCm aren’t confused: change the explanation around the
log message "ONNXruntime has CUDAExecutionProvider available, enabling
acceleration" shown by `audio-separator --env_info` to note that ONNXRuntime may
report CUDAExecutionProvider even when using ROCm (this is expected behavior and
indicates acceleration via ROCm/HIP mapping), and add a brief sentence telling
ROCm users that no further action is needed if ROCm drivers are installed.

audio_separator/separator/roformer/roformer_loader.py (1)

226-232: Consider using weights_only=True consistently in the new implementation path.

The legacy implementation attempts weights_only=True with a fallback for older PyTorch versions, but the new implementation at line 97 doesn't use this safer option.

🛡️ Suggested fix for safer model loading

             if os.path.exists(model_path):
-                state_dict = torch.load(model_path, map_location=device)
+                try:
+                    state_dict = torch.load(model_path, map_location=device, weights_only=True)
+                except TypeError:
+                    # For older torch versions without weights_only
+                    state_dict = torch.load(model_path, map_location=device)

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@audio_separator/separator/roformer/roformer_loader.py` around lines 226 -
232, The new loading path that calls torch.load(model_path, map_location=device)
should use the safer weights_only=True option like the legacy path; update the
torch.load call in the new implementation (where model_path and device are used)
to pass weights_only=True and wrap it in the same TypeError fallback to maintain
compatibility with older PyTorch versions (i.e., try torch.load(...,
map_location=device, weights_only=True) and except TypeError: torch.load(...,
map_location=device)).

debug_rocm_issues.py (2)

628-628: Remove extraneous f prefix.

-                print(f"✓ Matrix multiplication completed")
+                print("✓ Matrix multiplication completed")

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@debug_rocm_issues.py` at line 628, The print statement currently uses an
unnecessary f-string: replace the call print(f"✓ Matrix multiplication
completed") with a plain string print("✓ Matrix multiplication completed") to
remove the extraneous `f` prefix (locate the print call in debug_rocm_issues.py
and update it).

---

473-476: Remove extraneous f prefix from strings without placeholders.

Lines 474 and 476 have f-strings with no interpolation.

♻️ Suggested fix

         # Test memory layout of result
         if result_gpu.is_contiguous():
-            print(f"  Result is contiguous")
+            print("  Result is contiguous")
         else:
-            print(f"  Result is not contiguous")
+            print("  Result is not contiguous")

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@debug_rocm_issues.py` around lines 473 - 476, Remove the unnecessary f-string
prefixes on the print calls that check contiguity; update the two prints that
call result_gpu.is_contiguous() to use plain string literals (e.g., print(" 
Result is contiguous") and print("  Result is not contiguous")) instead of
print(f"...") so there is no unused interpolation prefix.

audio_separator/separator/separator.py (1)

99-127: Mutable default arguments could cause unexpected behavior.

Using mutable dictionaries as default arguments is a Python gotcha. While these specific dicts aren't mutated in the code, it's a best practice to use None and initialize inside the function.

♻️ Suggested fix pattern

     def __init__(
         self,
         ...
-        mdx_params={
-            "hop_length": 1024,
-            ...
-        },
+        mdx_params=None,
         ...
     ):
+        if mdx_params is None:
+            mdx_params = {
+                "hop_length": 1024,
+                ...
+            }

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@audio_separator/separator/separator.py` around lines 99 - 127, The default
parameter dicts mdx_params, vr_params, demucs_params, and mdxc_params are
mutable and should be changed to None in the function/class signature and then
initialized inside the function (e.g., if mdx_params is None: mdx_params =
{...}) to avoid shared-state bugs; update the function or constructor that
currently declares those defaults (referencing mdx_params, vr_params,
demucs_params, mdxc_params) to perform this lazy initialization so each
call/instance gets its own fresh dictionary.

audio_separator/separator/architectures/mdxc_separator.py (1)

550-553: Consider adding strict=True to zip() for safety.

When zipping instruments with inferenced outputs, using strict=True would catch length mismatches early rather than silently dropping data.

♻️ Suggested fix

             for key, value in zip(
                 self.model_data_cfgdict.training.instruments,
                 inferenced_outputs.cpu().detach().numpy(),
+                strict=True,
             ):

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@audio_separator/separator/architectures/mdxc_separator.py` around lines 550 -
553, The loop that pairs self.model_data_cfgdict.training.instruments with
inferenced_outputs.cpu().detach().numpy() should use zip(..., strict=True) to
surface any length mismatches immediately; update the for loop in mdxc_separator
(where the iteration over instruments and inferenced_outputs occurs) to call
zip(self.model_data_cfgdict.training.instruments,
inferenced_outputs.cpu().detach().numpy(), strict=True) and, if desired, wrap it
in a try/except to log a clear error message identifying MDXCSeparator and the
mismatched lengths before re-raising.

debug_rocm_issues.py (2)

474-477: Remove extraneous f prefix from strings without placeholders.

These f-strings contain no placeholders and should be regular strings per Ruff F541.

♻️ Proposed fix

         # Test memory layout of result
         if result_gpu.is_contiguous():
-            print(f"  Result is contiguous")
+            print("  Result is contiguous")
         else:
-            print(f"  Result is not contiguous")
+            print("  Result is not contiguous")

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@debug_rocm_issues.py` around lines 474 - 477, The two print statements inside
the result_gpu.is_contiguous() conditional use f-strings with no placeholders;
change them to plain strings by removing the leading 'f' so the prints become
standard strings (locate the prints in the result_gpu.is_contiguous() branch in
debug_rocm_issues.py).

---

236-237: Diagnostic script only runs test_model_types() despite having multiple test functions.

The main() function calls test_pytorch_rocm_setup() implicitly through the section prints but only explicitly calls test_model_types(). Consider running all test functions or documenting why others are skipped.

♻️ Proposed fix to run all tests

     # Check memory layout
     print_section("0.4 Memory Layout Check")
     # ... existing code ...

-    # Run only MDX model test for focused debugging
-    test_model_types()
+    # Run all diagnostic tests
+    test_pytorch_rocm_setup()
+    test_onnxruntime_setup()
+    test_stft_operations()
+    test_memory_allocation()
+    test_model_types()

     print("\n" + "=" * 50)

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@debug_rocm_issues.py` around lines 236 - 237, The main() currently only
invokes test_model_types(), so other diagnostics like test_pytorch_rocm_setup()
and test_onnxruntime() never run; update main() to explicitly call all test
functions (e.g., test_pytorch_rocm_setup(), test_onnxruntime(),
test_model_types()) in the intended order or add clear documentation/logging in
main() explaining why certain tests are intentionally skipped; locate the calls
in main() and add the missing function invocations (or comments) so the
diagnostic script executes every intended test.

audio_separator/separator/uvr_lib_v5/demucs/hdemucs_rocm.py (3)

221-221: Remove unnecessary int() casts on round() results.

In Python 3, round() returns an int when called with a single argument, making the outer int() call redundant.

♻️ Proposed fix

                 if ratio == 1:
                     limit = Fr
                     frames = -1
                 else:
-                    limit = int(round(Fr * ratio))
+                    limit = round(Fr * ratio)
                     le = limit - start

Also applies to: 242-242

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@audio_separator/separator/uvr_lib_v5/demucs/hdemucs_rocm.py` at line 221,
Remove the redundant int() casts around round() results in hdemucs_rocm.py:
replace occurrences like "limit = int(round(Fr * ratio))" (and the similar
occurrence at the other location) with just "limit = round(Fr * ratio)" so that
the value uses the int returned by round() in Python 3; update any nearby
assignments that wrap round(...) with int(...) accordingly (search for
"int(round(" to find all instances in this module, including the one at the
second mentioned location).

---

209-209: Prefix unused unpacked variables with underscore.

Variables B, C, T are unpacked but never used in the forward method. Prefix with _ to indicate intentional non-use.

♻️ Proposed fix

     def forward(self, x, skip=None, length=None):
-        B, C, Fr, T = x.shape
+        _B, _C, Fr, _T = x.shape

         ratios = list(self.split_ratios) + [1]

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@audio_separator/separator/uvr_lib_v5/demucs/hdemucs_rocm.py` at line 209, In
the forward method where the input shape is unpacked (currently "B, C, Fr, T =
x.shape"), prefix the unused variables B, C, and T with an underscore (e.g., _B,
_C, _T) so they are marked as intentionally unused; update the unpacking near
the start of hdemucs_rocm.forward (the line unpacking x.shape) to use _B, _C,
Fr, _T and ensure downstream code still references only Fr.

---

33-34: Assertion may fail silently in production if optimizations are enabled.

The assertions at lines 33-34 verify padding correctness but will be stripped when Python runs with -O flag. Consider using explicit checks with exceptions for critical invariants if this code runs in optimized mode.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@audio_separator/separator/uvr_lib_v5/demucs/hdemucs_rocm.py` around lines 33
- 34, Replace the two assert statements that check padding correctness (the
lines using out.shape and comparing out[..., padding_left : padding_left +
length] == x0) with explicit runtime checks that raise a clear exception (e.g.,
ValueError or RuntimeError) when the invariants fail; use the same symbols (out,
padding_left, padding_right, length, x0) and perform a strict shape check for
out.shape[-1] == length + padding_left + padding_right and an element-wise
equality check (using the appropriate array/tensor equality helper in this
module) and include the actual values in the error message to aid debugging.

audio_separator/separator/uvr_lib_v5/stft.py (2)

52-71: Catch a more specific exception type.

The bare Exception catch is too broad per Ruff BLE001. Since this fallback handles torch.stft compatibility issues, catching RuntimeError or TypeError would be more appropriate.

♻️ Proposed fix

         # Perform the Short-Time Fourier Transform (STFT) on the reshaped tensor.
         try:
             stft_output = torch.stft(
                 reshaped_tensor,
                 n_fft=self.n_fft,
                 hop_length=self.hop_length,
                 window=stft_window,
                 center=True,
                 return_complex=False,
             )
-        except Exception as e:
+        except RuntimeError:
             # Fallback: try with return_complex=True
             stft_complex = torch.stft(
                 reshaped_tensor,
                 n_fft=self.n_fft,
                 hop_length=self.hop_length,
                 window=stft_window,
                 center=True,
                 return_complex=True,
             )
             stft_output = torch.stack([stft_complex.real, stft_complex.imag], dim=-1)

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@audio_separator/separator/uvr_lib_v5/stft.py` around lines 52 - 71, The
current broad except Exception around the torch.stft call should be narrowed to
only the compatibility-related errors; change the handler to catch RuntimeError
and TypeError instead of Exception so the fallback path (which computes
stft_complex and sets stft_output from stft_complex.real/imag for
reshaped_tensor) only runs for those specific torch.stft compatibility failures
and doesn't swallow unrelated exceptions.

---

25-27: Unused variable original_dtype in forward path.

The original_dtype is stored but never used. If dtype restoration is intended, implement it; otherwise, remove the unused variable.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@audio_separator/separator/uvr_lib_v5/stft.py` around lines 25 - 27, The
variable original_dtype is captured but never used in the forward path; either
remove its assignment or use it to restore tensor dtypes after processing:
locate the forward function where original_dtype is set (search for
original_dtype and input_tensor) and if dtype preservation is intended, cast the
final output(s) back to original_dtype (e.g., convert result tensors to
original_dtype before returning), otherwise delete the original_dtype assignment
to avoid the unused variable. Ensure any restoration happens after all CUDA/CPU
device logic (around run_on_cpu and subsequent transforms) so device and dtype
are correctly reconciled.

audio_separator/separator/uvr_lib_v5/tfc_tdf_v3.py (2)

25-27: Remove unused original_dtype variables.

original_dtype is stored in both __call__ (line 25) and inverse (line 67) but never used. Remove these or implement dtype restoration if intended.

♻️ Proposed fix

         if run_on_cpu:
             x = x.cpu()

         # Ensure FP32 for stability on ROCm and non-standard devices
-        original_dtype = x.dtype
         if x.dtype in (torch.float16, torch.bfloat16):
             x = x.float()

Also applies to: 67-69

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@audio_separator/separator/uvr_lib_v5/tfc_tdf_v3.py` around lines 25 - 27,
Remove the unused variable original_dtype in both the __call__ and inverse
methods of tfc_tdf_v3.py: delete the lines that assign original_dtype = x.dtype
(and any corresponding unused references) since dtype restoration is not
implemented; if you intended to preserve dtype instead, replace those lines by
storing dtype and then casting the output back to that dtype (e.g., out =
out.to(original_dtype)) at the end of the method. Ensure the change touches the
original_dtype assignments in __call__ and inverse only.

---

5-6: Remove unused is_rocm import.

The is_rocm function is imported but never used in this file. Either remove the unused import or integrate ROCm-aware logic as done in stft.py.

♻️ Proposed fix

 import torch
 import torch.nn as nn
 from functools import partial
 
-from audio_separator.separator.uvr_lib_v5.utils import is_rocm
-
-
+
 class STFT:

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@audio_separator/separator/uvr_lib_v5/tfc_tdf_v3.py` around lines 5 - 6,
Remove the unused import is_rocm from
audio_separator.separator.uvr_lib_v5.tfc_tdf_v3.py or add ROCm-aware branching
similar to stft.py; specifically either delete the line importing is_rocm or use
is_rocm() inside the relevant functions (e.g., any tensor/device setup in
tfc_tdf_v3 functions) to select the correct backend/device code path as done in
stft.py so the import is actually used.

Dockerfile.rocm (1)

1-34: Consider adding a non-root user for security.

The container runs as root by default, which Trivy flagged as a security concern (DS-0002). For production use, consider adding a non-root user.

♻️ Proposed fix

 # Install audio-separator with GPU support
 RUN --mount=type=cache,target=/root/.cache \
     pip3 install "audio-separator[gpu]" onnxruntime-rocm

+# Create non-root user for security
+RUN useradd -m -s /bin/bash separator
+USER separator
+WORKDIR /home/separator/workdir
+
 # Default environment variables for AMD RX 6600 series (gfx1032)

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@Dockerfile.rocm` around lines 1 - 34, Add a non-root user and switch to it
before CMD/ENTRYPOINT: create a group and user (optionally via build args like
UID/GID), chown the WORKDIR (/workdir) and any cache or pip directories to that
user, set HOME and USER environment variables, and add a USER instruction so the
container no longer runs as root; ensure this change is applied before the
ENTRYPOINT ["audio-separator"] so the process starts as the non-root account.

debug_rocm_issues.py (2)

402-407: ⚠️ Potential issue | 🟡 Minor

Don’t swallow install-path scan failures.

This bare except: pass hides permission and I/O errors in the middle of the ROCm installation diagnostic. Catch OSError and print a short note instead so users can tell whether the path was absent or just unreadable.

♻️ Proposed fix

-                    except:
-                        pass
+                    except OSError as exc:
+                        print(f"  Could not inspect {path}: {exc}")

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@debug_rocm_issues.py` around lines 402 - 407, Replace the bare except in the
os.listdir(path) scan with an OSError handler so you don't swallow
permission/I/O errors: in the try/except around os.listdir(path) (the block that
checks "lib" or "bin" and prints "ROCm components detected in {path}"), catch
OSError and print a short diagnostic like "Unable to read {path}: {error}" (or
similar) instead of silently passing; keep other exceptions uncaught so they
surface.

---

107-109: ⚠️ Potential issue | 🟠 Major

Don’t hard-code ROCm env overrides at import time.

These assignments mutate the process as soon as the module is imported, so the report no longer reflects the user’s real environment. They also happen after import torch, which can be too late for ROCm/PyTorch initialization, and PYTORCH_ROCM_ARCH="gfx1030" will be wrong for non-gfx1030 cards.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@debug_rocm_issues.py` around lines 107 - 109, The module currently hard-sets
HSA_OVERRIDE_GFX_VERSION and PYTORCH_ROCM_ARCH at import time (after import
torch), which mutates the process and can be too late or incorrect; remove these
top‑level os.environ assignments and instead provide a function (e.g.,
set_rocm_env or configure_rocm_env) that (1) checks for existing environment
variables and only sets defaults if they are unset, (2) detects the GPU/ROCm
version dynamically (via rocminfo or a safe detection routine) to choose the
correct PYTORCH_ROCM_ARCH value instead of forcing "gfx1030", and (3) must be
called before importing torch when the caller explicitly wants to override the
environment. Ensure the code references HSA_OVERRIDE_GFX_VERSION and
PYTORCH_ROCM_ARCH only within that function and do not perform mutations at
module import time.

audio_separator/separator/separator.py (1)

1027-1029: ⚠️ Potential issue | 🟠 Major

Still parsing downloaded YAML with yaml.FullLoader.

download_model_files() can fetch model configs from remote repos, and this method still parses them with yaml.load(..., Loader=yaml.FullLoader). Please switch to yaml.safe_load and a context manager before shipping more remote model/config support.

Run the following script to confirm the remote-download path and the loader currently in use:

#!/bin/bash
sed -n '950,1035p' audio_separator/separator/separator.py
rg -n "yaml\.load|yaml\.safe_load|FullLoader" audio_separator/separator/separator.py

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@audio_separator/separator/separator.py` around lines 1027 - 1029, The code at
the yaml parsing site uses yaml.load with yaml.FullLoader when reading
model_data_yaml_filepath (used to produce model_data), which is unsafe for
remote configs; change the logic that reads the file (the block that assigns
model_data) to open the file with a context manager (with
open(model_data_yaml_filepath, encoding="utf-8") as f:) and parse via
yaml.safe_load(f) instead of yaml.load(..., Loader=yaml.FullLoader); ensure any
other occurrences in the same module (and in the download_model_files() code
path) are updated to safe_load to avoid insecure parsing.

README.md (2)

207-219: ⚠️ Potential issue | 🟠 Major

Split the recovery commands by backend or make this section CUDA-only again.

After Line 209 distinguishes [gpu] vs [rocm], the example immediately below unconditionally reinstalls onnxruntime-gpu. A ROCm user following these steps will replace the AMD runtime with the CUDA package.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@README.md` around lines 207 - 219, The recovery commands currently
unconditionally reinstall onnxruntime-gpu which will break ROCm users; update
the README section that follows the `[gpu]` vs `[rocm]` note to either split the
example into two backend-specific blocks or revert this paragraph to be
CUDA-only: keep the generic uninstall/cache steps (`pip uninstall torch
onnxruntime` and `pip cache purge`) but show separate reinstall commands — `pip
install --force-reinstall torch torchvision torchaudio` + `pip install
--force-reinstall onnxruntime-gpu` for CUDA/NVIDIA (`[gpu]`) and the appropriate
ROCm runtime install for AMD (`[rocm]`) — and clearly label each block so
readers for `onnxruntime-gpu` are only those using `[gpu]`.

---

122-153: ⚠️ Potential issue | 🟠 Major

The ROCm installation section still mixes ROCm and CUDA instructions.

This block currently disagrees with the new ROCm packaging/runtime path: the two pip snippets use different ROCm wheel indexes, both installs still use [gpu], the package list still mentions onnxruntime-gpu, and the success signal only names CUDAExecutionProvider even though Separator.configure_rocm() prefers ROCMExecutionProvider. AMD users can end up installing the wrong runtime or think a correct ROCm setup failed.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@README.md` around lines 122 - 153, The README mixes CUDA and ROCm
instructions; update the ROCm section to consistently use the same ROCm wheel
index, stop referencing CUDA artifacts, and reflect what
Separator.configure_rocm() expects: replace both pip snippets to use a single
ROCm wheel index (e.g., https://download.pytorch.org/whl/rocm7.2), change
package install examples to install PyTorch ROCm first and then pip install
"audio-separator[rocm]" (or the correct extra for ROCm), remove mentions of
onnxruntime-gpu from the Required ROCm Packages (keep onnxruntime and
onnxruntime-rocm only), and change the success log example to "ONNXruntime has
ROCMExecutionProvider available, enabling acceleration" to match
Separator.configure_rocm().

debug_minimal.py (1)

26-44: Include tracebacks in the debug report.

Both exception paths only keep str(e), which drops the stack and import/provider context users usually need to diagnose ROCm failures. For a troubleshooting script, capture the traceback too.

🛠️ Suggested change

+import traceback
...
     except Exception as e:
         output.append(f"Error: {e}")
+        output.append(traceback.format_exc())
...
     except Exception as e:
         output.append(f"Error: {e}")
+        output.append(traceback.format_exc())

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@debug_minimal.py` around lines 26 - 44, The except blocks in the Torch and
ONNX Runtime checks currently append only str(e), losing stack traces; update
the exception handlers in the try/except around importing torch and onnxruntime
(the blocks that append "Error: {e}") to also capture and append the full
traceback (e.g., via traceback.format_exc()) so the debug output includes the
stack and import/provider context—import the traceback module at top if not
present and include the formatted traceback alongside the existing error message
for both exception handlers.